package com.zq.新特性.stream;

import org.assertj.core.util.Lists;
import org.junit.jupiter.api.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * @Description：流集合测试
 * @Author qu
 * @Date 2020/11/4 15:46
 */
public class StreamTest {

    public static List<Student> stu = streamTest();
    //@Test
    //@BeforeAll
    public static List<Student> streamTest(){
        Student s1 = new Student("zhangsan",10);
        Student s2 = new Student("lisi",11);
        Student s3 = new Student("wangwu",11);
        Student s4 = new Student("zhaoliu",13);
        return Lists.list(s1, s2, s3, s4);

    }

    @Test
    List<Student> stream1Test(){
        Student s1 = new Student("zhangsan",10);
        Student s2 = new Student("lisi",11);
        Student s3 = new Student("wangwu",11);
        Student s4 = new Student("zhaoliu",13);
        List<Student> stu = new ArrayList<Student>();
        stu.add(s1);
        stu.add(s2);
        stu.add(s3);
        stu.add(s4);
        return stu;
    }
    @Test
    void test1Filter(){
        stu.stream().filter(s -> s.getAge() == 11).collect(Collectors.toList()).forEach(System.out::println);
    }

    /** 
    * @Description: 过滤：filter 按指定条件过滤重新生成集合。
    * @Param  
    * @Returns: void 
    * @Author: qudp 
    * @Date: 2020/11/4 16:07 
    */
    @Test
    void testFilter(){
        stu.stream().filter(s -> s.getAge() == 11).collect(Collectors.toList()).forEach(System.out::println);
    }

    @Test
    void testLimit(){
        //取前一个
//        stu.stream().limit(1).forEach(System.out::println);
        //跳过前2个
        stu.stream().skip(2).forEach(System.out::println);
    }
    @Test
    void testMap(){
        //组成个新集合
        stu.stream().map(s -> s.getName()).collect(Collectors.toList()).forEach(System.out::println);
    }
    /**
    * @Description: 数据准备
    * @Param
    * @Returns: java.util.List<com.interest.expand.test.bean.Transaction>
    * @Author: qudp
    * @Date: 2020/11/4 16:32
    */

    public static List<Transaction> tran = testTrader();
    static List<Transaction> testTrader(){
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario","Milan");
        Trader alan = new Trader("Alan","Cambridge");
        Trader brian = new Trader("Brian","Cambridge");
        List<Transaction> transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );
        return transactions;
    }

    //(1) 找出2011年发生的所有交易，并按交易额排序（从低到高）。
    @Test
    void testFind(){
        tran.stream().filter(tra -> tra.getYear() == 2011).sorted(
                Comparator.comparing(Transaction::getValue)
        ).forEach(System.out::println);
    }
    //(2) 交易员都在哪些不同的城市工作过？
    @Test
    void testCity(){
        tran.stream().map(t -> t.getTrader()).distinct().forEach(System.out::println);
    }

    //(3) 查找所有来自于剑桥的交易员，并按姓名排序。
    @Test
    void testSort(){
        tran.stream().map(t -> t.getTrader()).distinct().filter(tra -> tra.getCity()
                .equals("Cambridge")).sorted(Comparator.comparing(Trader::getName))
                .forEach(System.out::println);
        System.out.println("-----------");
        tran.stream().map(t ->t.getTrader()).distinct().filter(tra -> tra.getCity().equals("Cambridge"))
                .sorted(Comparator.comparing(Trader::getName)).forEach(System.out::println);
    }

    //(4) 返回所有交易员的姓名字符串，按字母顺序排序。
    @Test
    void testByte(){
        String collect = tran.stream().map(t -> t.getTrader().getName())
                .distinct()
                .sorted()
                .collect(Collectors.joining("->","[","]"));
        // Collectors.joining() 字符串拼接 -- 可传参/不传
        System.out.println(collect);
    }
    //(5) 有没有交易员是在米兰工作的？
    @Test
    void findTrad(){
        //判断有没有
        System.out.println(tran.stream().map(t -> t.getTrader().getCity()).anyMatch(Predicate.isEqual("Milan")));
        //可以拿到都谁在
        tran.stream().map(t -> t.getTrader()).distinct().filter(t -> t.getCity().equals("Milan"))
                .forEach(System.out::println);
    }
    //(6) 打印生活在剑桥的交易员的所有交易额
    @Test
    void testSumValue(){
        tran.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
                .map(tt -> tt.getValue()).forEach(System.out::println);
        //可以深层次条件筛选，相当于把两个list合并到一起了
        tran.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
                .forEach(System.out::println);
        //可以同时，对这两个做聚合/筛选操作
        tran.stream().filter(t -> t.getTrader().getCity().equals("Cambridge"))
                .map(ttt -> ttt.getTrader().getCity())
                .forEach(System.out::println);
    }

    //(7) 所有交易中，最高的交易额是多少？
    @Test
    void testMaxOrMin(){
        //两种不同的获取方法，一种是返回最大值，一种是返回最小值这个对象
        System.out.println(tran.stream().map(t -> t.getValue()).max(Comparator.comparing(Integer::intValue)).get());

        System.out.println(tran.stream().min(Comparator.comparing(t -> t.getValue())));
    }
    //(8) 按不同年份 -- 转为新的分组
    @Test
    void testGroup(){
        //得到的是一个新map
        tran.stream().collect(Collectors.groupingBy(Transaction::getYear))
                .forEach((x,y) -> {
                    System.out.println(x);
                    y.forEach(t -> System.out.println(t));
                });
        //可以组成不同key/value形式
        tran.stream().collect(Collectors.groupingBy(t -> t.getTrader().getCity() + "_" + t.getYear()))
                .forEach((x,y) -> {
                    System.out.println(x);
                    y.forEach(t -> System.out.println(t));
                });

    }
}
